home *** CD-ROM | disk | FTP | other *** search
/ QuickTime 2.0 Beta / Quicktime 2.0 Beta.iso / Programming Stuff / Interfaces / Universal Interfaces / Connections.h < prev    next >
Encoding:
C/C++ Source or Header  |  1994-01-30  |  13.0 KB  |  385 lines  |  [TEXT/MPS ]
  1. /*
  2.     File:        Connections.h
  3.  
  4.     Copyright:    © 1984-1993 by Apple Computer, Inc., all rights reserved.
  5.  
  6.     WARNING
  7.     This file was auto generated by the interfacer tool. Modifications
  8.     must be made to the master file.
  9.  
  10. */
  11.  
  12. #ifndef    __CONNECTIONS__
  13. #define __CONNECTIONS__
  14.  
  15. #ifndef __DIALOGS__
  16. #include <Dialogs.h>
  17. /*    #include <Windows.h>                                        */
  18. /*        #include <Quickdraw.h>                                    */
  19. /*            #include <Types.h>                                    */
  20. /*                #include <ConditionalMacros.h>                    */
  21. /*                #include <MixedMode.h>                            */
  22. /*                    #include <Traps.h>                            */
  23. /*            #include <QuickdrawText.h>                            */
  24. /*                #include <IntlResources.h>                        */
  25. /*        #include <Events.h>                                        */
  26. /*            #include <OSUtils.h>                                */
  27. /*        #include <Controls.h>                                    */
  28. /*            #include <Menus.h>                                    */
  29. /*    #include <TextEdit.h>                                        */
  30. #endif
  31.  
  32. #ifndef __CTBUTILITIES__
  33. #include <CTBUtilities.h>
  34. /*    #include <Memory.h>                                            */
  35. /*    #include <StandardFile.h>                                    */
  36. /*        #include <Files.h>                                        */
  37. /*            #include <SegLoad.h>                                */
  38. /*    #include <AppleTalk.h>                                        */
  39. #endif
  40.  
  41. enum  {
  42. /*    current Connection Manager version    */
  43.     curCMVersion                = 2,
  44. /*    current Connection Manager Environment Record version     */
  45.     curConnEnvRecVers            = 0,
  46. /* CMErr */
  47.     cmGenericError                = -1,
  48.     cmNoErr                        = 0,
  49.     cmRejected                    = 1,
  50.     cmFailed                    = 2,
  51.     cmTimeOut                    = 3,
  52.     cmNotOpen                    = 4,
  53.     cmNotClosed                    = 5,
  54.     cmNoRequestPending            = 6,
  55.     cmNotSupported                = 7,
  56.     cmNoTools                    = 8,
  57.     cmUserCancel                = 9,
  58.     cmUnknownError                = 11
  59. };
  60.  
  61. typedef OSErr CMErr;
  62.  
  63. enum  {
  64.     cmData                        = 1L << 0,
  65.     cmCntl                        = 1L << 1,
  66.     cmAttn                        = 1L << 2,
  67.     cmDataNoTimeout                = 1L << 4,
  68.     cmCntlNoTimeout                = 1L << 5,
  69.     cmAttnNoTimeout                = 1L << 6,
  70.     cmDataClean                    = 1L << 8,
  71.     cmCntlClean                    = 1L << 9,
  72.     cmAttnClean                    = 1L << 10,
  73. /*        Only for CMRecFlags (not CMChannel) in the rest of this enum    */
  74.     cmNoMenus                    = 1L << 16,
  75.     cmQuiet                        = 1L << 17,
  76.     cmConfigChanged                = 1L << 18
  77. };
  78.  
  79.  
  80. /* CMRecFlags and CMChannel        */
  81.  
  82.  
  83. /*        Low word of CMRecFlags is same as CMChannel    */
  84.  
  85. typedef long CMRecFlags;
  86.  
  87. typedef short CMChannel;
  88.  
  89. enum  {
  90.     cmStatusOpening                = 1L << 0,
  91.     cmStatusOpen                = 1L << 1,
  92.     cmStatusClosing                = 1L << 2,
  93.     cmStatusDataAvail            = 1L << 3,
  94.     cmStatusCntlAvail            = 1L << 4,
  95.     cmStatusAttnAvail            = 1L << 5,
  96.     cmStatusDRPend                = 1L << 6,                        /* data read pending    */
  97.     cmStatusDWPend                = 1L << 7,                        /* data write pending    */
  98.     cmStatusCRPend                = 1L << 8,                        /* cntl read pending    */
  99.     cmStatusCWPend                = 1L << 9,                        /* cntl write pending    */
  100.     cmStatusARPend                = 1L << 10,                        /* attn read pending    */
  101.     cmStatusAWPend                = 1L << 11,                        /* attn write pending    */
  102.     cmStatusBreakPend            = 1L << 12,
  103.     cmStatusListenPend            = 1L << 13,
  104.     cmStatusIncomingCallPresent    = 1L << 14,
  105.     cmStatusReserved0            = 1L << 15
  106. };
  107.  
  108. typedef unsigned long CMStatFlags;
  109.  
  110. enum  {
  111.     cmDataIn,
  112.     cmDataOut,
  113.     cmCntlIn,
  114.     cmCntlOut,
  115.     cmAttnIn,
  116.     cmAttnOut,
  117.     cmRsrvIn,
  118.     cmRsrvOut
  119. };
  120.  
  121. typedef unsigned short CMBufFields;
  122.  
  123. typedef Ptr CMBuffers[8];
  124.  
  125. typedef long CMBufferSizes[8];
  126.  
  127. typedef const long *ConstCMBufferSizesParam;
  128.  
  129. enum  {
  130.     cmSearchSevenBit            = 1L << 0
  131. };
  132.  
  133. typedef unsigned short CMSearchFlags;
  134.  
  135. enum  {
  136.     cmFlagsEOM                    = 1L << 0
  137. };
  138.  
  139. typedef unsigned short CMFlags;
  140.  
  141. #if defined(powerc) || defined (__powerc)
  142. #pragma options align=mac68k
  143. #endif
  144. struct ConnEnvironRec {
  145.     short                        version;
  146.     long                        baudRate;
  147.     short                        dataBits;
  148.     CMChannel                    channels;
  149.     Boolean                        swFlowControl;
  150.     Boolean                        hwFlowControl;
  151.     CMFlags                        flags;
  152. };
  153. #if defined(powerc) || defined(__powerc)
  154. #pragma options align=reset
  155. #endif
  156.  
  157. typedef struct ConnEnvironRec ConnEnvironRec;
  158.  
  159. typedef ConnEnvironRec *ConnEnvironRecPtr;
  160.  
  161. typedef struct ConnRecord ConnRecord, *ConnPtr, **ConnHandle;
  162.  
  163. typedef pascal long (*ConnectionToolDefProcPtr)(ConnHandle hConn, short msg, long p1, long p2, long p3);
  164.  
  165. enum {
  166.     uppConnectionToolDefProcInfo = kPascalStackBased
  167.          | RESULT_SIZE(SIZE_CODE(sizeof(long)))
  168.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(ConnHandle)))
  169.          | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(short)))
  170.          | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(long)))
  171.          | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(long)))
  172.          | STACK_ROUTINE_PARAMETER(5, SIZE_CODE(sizeof(long)))
  173. };
  174.  
  175. #if USESROUTINEDESCRIPTORS
  176. typedef UniversalProcPtr ConnectionToolDefUPP;
  177.  
  178. #define CallConnectionToolDefProc(userRoutine, hConn, msg, p1, p2, p3)        \
  179.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppConnectionToolDefProcInfo, (hConn), (msg), (p1), (p2), (p3))
  180. #define NewConnectionToolDefProc(userRoutine)        \
  181.         (ConnectionToolDefUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppConnectionToolDefProcInfo, GetCurrentISA())
  182. #else
  183. typedef ConnectionToolDefProcPtr ConnectionToolDefUPP;
  184.  
  185. #define CallConnectionToolDefProc(userRoutine, hConn, msg, p1, p2, p3)        \
  186.         (*(userRoutine))((hConn), (msg), (p1), (p2), (p3))
  187. #define NewConnectionToolDefProc(userRoutine)        \
  188.         (ConnectionToolDefUPP)(userRoutine)
  189. #endif
  190.  
  191. #if defined(powerc) || defined (__powerc)
  192. #pragma options align=mac68k
  193. #endif
  194. struct ConnRecord {
  195.     short                        procID;
  196.     CMRecFlags                    flags;
  197.     CMErr                        errCode;
  198.     long                        refCon;
  199.     long                        userData;
  200.     ConnectionToolDefUPP        defProc;
  201.     Ptr                            config;
  202.     Ptr                            oldConfig;
  203.     long                        asyncEOM;
  204.     long                        reserved1;
  205.     long                        reserved2;
  206.     Ptr                            cmPrivate;
  207.     CMBuffers                    bufferArray;
  208.     CMBufferSizes                bufSizes;
  209.     long                        mluField;
  210.     CMBufferSizes                asyncCount;
  211. };
  212. #if defined(powerc) || defined(__powerc)
  213. #pragma options align=reset
  214. #endif
  215.  
  216.  
  217. /*    application routines type definitions */
  218.  
  219. typedef pascal void (*ConnectionSearchCallBackProcPtr)(ConnHandle hConn, Ptr matchPtr, long refNum);
  220.  
  221. enum {
  222.     uppConnectionSearchCallBackProcInfo = kPascalStackBased
  223.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(ConnHandle)))
  224.          | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(Ptr)))
  225.          | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(long)))
  226. };
  227.  
  228. #if USESROUTINEDESCRIPTORS
  229. typedef UniversalProcPtr ConnectionSearchCallBackUPP;
  230.  
  231. #define CallConnectionSearchCallBackProc(userRoutine, hConn, matchPtr, refNum)        \
  232.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppConnectionSearchCallBackProcInfo, (hConn), (matchPtr), (refNum))
  233. #define NewConnectionSearchCallBackProc(userRoutine)        \
  234.         (ConnectionSearchCallBackUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppConnectionSearchCallBackProcInfo, GetCurrentISA())
  235. #else
  236. typedef ConnectionSearchCallBackProcPtr ConnectionSearchCallBackUPP;
  237.  
  238. #define CallConnectionSearchCallBackProc(userRoutine, hConn, matchPtr, refNum)        \
  239.         (*(userRoutine))((hConn), (matchPtr), (refNum))
  240. #define NewConnectionSearchCallBackProc(userRoutine)        \
  241.         (ConnectionSearchCallBackUPP)(userRoutine)
  242. #endif
  243.  
  244. typedef pascal void (*ConnectionCompletionProcPtr)(ConnHandle hConn);
  245.  
  246. enum {
  247.     uppConnectionCompletionProcInfo = kPascalStackBased
  248.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(ConnHandle)))
  249. };
  250.  
  251. #if USESROUTINEDESCRIPTORS
  252. typedef UniversalProcPtr ConnectionCompletionUPP;
  253.  
  254. #define CallConnectionCompletionProc(userRoutine, hConn)        \
  255.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppConnectionCompletionProcInfo, (hConn))
  256. #define NewConnectionCompletionProc(userRoutine)        \
  257.         (ConnectionCompletionUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppConnectionCompletionProcInfo, GetCurrentISA())
  258. #else
  259. typedef ConnectionCompletionProcPtr ConnectionCompletionUPP;
  260.  
  261. #define CallConnectionCompletionProc(userRoutine, hConn)        \
  262.         (*(userRoutine))((hConn))
  263. #define NewConnectionCompletionProc(userRoutine)        \
  264.         (ConnectionCompletionUPP)(userRoutine)
  265. #endif
  266.  
  267. typedef pascal void (*ConnectionChooseIdleProcPtr)(void);
  268.  
  269. enum {
  270.     uppConnectionChooseIdleProcInfo = kPascalStackBased
  271. };
  272.  
  273. #if USESROUTINEDESCRIPTORS
  274. typedef UniversalProcPtr ConnectionChooseIdleUPP;
  275.  
  276. #define CallConnectionChooseIdleProc(userRoutine)        \
  277.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppConnectionChooseIdleProcInfo)
  278. #define NewConnectionChooseIdleProc(userRoutine)        \
  279.         (ConnectionChooseIdleUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppConnectionChooseIdleProcInfo, GetCurrentISA())
  280. #else
  281. typedef ConnectionChooseIdleProcPtr ConnectionChooseIdleUPP;
  282.  
  283. #define CallConnectionChooseIdleProc(userRoutine)        \
  284.         (*(userRoutine))()
  285. #define NewConnectionChooseIdleProc(userRoutine)        \
  286.         (ConnectionChooseIdleUPP)(userRoutine)
  287. #endif
  288.  
  289. enum  {
  290. /* CMIOPB constants and structure */
  291.     cmIOPBQType                    = 10,
  292.     cmIOPBversion                = 0
  293. };
  294.  
  295. #if defined(powerc) || defined (__powerc)
  296. #pragma options align=mac68k
  297. #endif
  298. struct CMIOPB {
  299.     QElemPtr                    qLink;
  300.     short                        qType;                            /* cmIOPBQType */
  301.     ConnHandle                    hConn;
  302.     Ptr                            theBuffer;
  303.     long                        count;
  304.     CMFlags                        flags;
  305.     ConnectionCompletionUPP        userCompletion;
  306.     long                        timeout;
  307.     CMErr                        errCode;
  308.     CMChannel                    channel;
  309.     long                        asyncEOM;
  310.     long                        reserved1;
  311.     short                        reserved2;
  312.     short                        version;                        /* cmIOPBversion */
  313.     long                        refCon;                            /* for application */
  314.     long                        toolData1;                        /* for tool */
  315.     long                        toolData2;                        /* for tool */
  316. };
  317. #if defined(powerc) || defined(__powerc)
  318. #pragma options align=reset
  319. #endif
  320.  
  321. typedef struct CMIOPB CMIOPB;
  322.  
  323. typedef CMIOPB *CMIOPBPtr;
  324.  
  325. #ifdef __cplusplus
  326. extern "C" {
  327. #endif
  328.  
  329. extern pascal CMErr InitCM(void);
  330. extern pascal Handle CMGetVersion(ConnHandle hConn);
  331. extern pascal short CMGetCMVersion(void);
  332. extern pascal ConnHandle CMNew(short procID, CMRecFlags flags, ConstCMBufferSizesParam desiredSizes, long refCon, long userData);
  333. extern pascal void CMDispose(ConnHandle hConn);
  334. extern pascal CMErr CMListen(ConnHandle hConn, Boolean async, ConnectionCompletionUPP completor, long timeout);
  335. extern pascal CMErr CMAccept(ConnHandle hConn, Boolean accept);
  336. extern pascal CMErr CMOpen(ConnHandle hConn, Boolean async, ConnectionCompletionUPP completor, long timeout);
  337. extern pascal CMErr CMClose(ConnHandle hConn, Boolean async, ConnectionCompletionUPP completor, long timeout, Boolean now);
  338. extern pascal CMErr CMAbort(ConnHandle hConn);
  339. extern pascal CMErr CMStatus(ConnHandle hConn, CMBufferSizes sizes, CMStatFlags *flags);
  340. extern pascal void CMIdle(ConnHandle hConn);
  341. extern pascal void CMReset(ConnHandle hConn);
  342. extern pascal void CMBreak(ConnHandle hConn, long duration, Boolean async, ConnectionCompletionUPP completor);
  343. extern pascal CMErr CMRead(ConnHandle hConn, void *theBuffer, long *toRead, CMChannel theChannel, Boolean async, ConnectionCompletionUPP completor, long timeout, CMFlags *flags);
  344. extern pascal CMErr CMWrite(ConnHandle hConn, const void *theBuffer, long *toWrite, CMChannel theChannel, Boolean async, ConnectionCompletionUPP completor, long timeout, CMFlags flags);
  345. extern pascal CMErr CMIOKill(ConnHandle hConn, short which);
  346. extern pascal void CMActivate(ConnHandle hConn, Boolean activate);
  347. extern pascal void CMResume(ConnHandle hConn, Boolean resume);
  348. extern pascal Boolean CMMenu(ConnHandle hConn, short menuID, short item);
  349. extern pascal Boolean CMValidate(ConnHandle hConn);
  350. extern pascal void CMDefault(Ptr *theConfig, short procID, Boolean allocate);
  351. extern pascal Handle CMSetupPreflight(short procID, long *magicCookie);
  352. extern pascal Boolean CMSetupFilter(short procID, const void *theConfig, short count, DialogPtr theDialog, EventRecord *theEvent, short *theItem, long *magicCookie);
  353. extern pascal void CMSetupSetup(short procID, const void *theConfig, short count, DialogPtr theDialog, long *magicCookie);
  354. extern pascal void CMSetupItem(short procID, const void *theConfig, short count, DialogPtr theDialog, short *theItem, long *magicCookie);
  355. extern pascal void CMSetupXCleanup(short procID, const void *theConfig, short count, DialogPtr theDialog, Boolean OKed, long *magicCookie);
  356. extern pascal void CMSetupPostflight(short procID);
  357. extern pascal Ptr CMGetConfig(ConnHandle hConn);
  358. extern pascal short CMSetConfig(ConnHandle hConn, const void *thePtr);
  359. extern pascal OSErr CMIntlToEnglish(ConnHandle hConn, const void *inputPtr, Ptr *outputPtr, short language);
  360. extern pascal OSErr CMEnglishToIntl(ConnHandle hConn, const void *inputPtr, Ptr *outputPtr, short language);
  361. extern pascal long CMAddSearch(ConnHandle hConn, ConstStr255Param theString, CMSearchFlags flags, ConnectionSearchCallBackUPP callBack);
  362. extern pascal void CMRemoveSearch(ConnHandle hConn, long refnum);
  363. extern pascal void CMClearSearch(ConnHandle hConn);
  364. extern pascal CMErr CMGetConnEnvirons(ConnHandle hConn, ConnEnvironRec *theEnvirons);
  365. extern pascal short CMChoose(ConnHandle *hConn, Point where, ConnectionChooseIdleUPP idle);
  366. extern pascal void CMEvent(ConnHandle hConn, const EventRecord *theEvent);
  367. extern pascal void CMGetToolName(short procID, Str255 name);
  368. extern pascal short CMGetProcID(ConstStr255Param name);
  369. extern pascal void CMSetRefCon(ConnHandle hConn, long refCon);
  370. extern pascal long CMGetRefCon(ConnHandle hConn);
  371. extern pascal long CMGetUserData(ConnHandle hConn);
  372. extern pascal void CMSetUserData(ConnHandle hConn, long userData);
  373. extern pascal void CMGetErrorString(ConnHandle hConn, short id, Str255 errMsg);
  374. extern pascal CMErr CMNewIOPB(ConnHandle hConn, CMIOPBPtr *theIOPB);
  375. extern pascal CMErr CMDisposeIOPB(ConnHandle hConn, CMIOPBPtr theIOPB);
  376. extern pascal CMErr CMPBRead(ConnHandle hConn, CMIOPBPtr theIOPB, Boolean async);
  377. extern pascal CMErr CMPBWrite(ConnHandle hConn, CMIOPBPtr theIOPB, Boolean async);
  378. extern pascal CMErr CMPBIOKill(ConnHandle hConn, CMIOPBPtr theIOPB);
  379. #ifdef __cplusplus
  380. }
  381. #endif
  382.  
  383. #endif
  384.  
  385.